//
//  Problem1763.swift
//  TestProject
//
//  Created by 武侠 on 2021/3/18.
//  Copyright © 2021 zhulong. All rights reserved.
//

import UIKit
/*
 1763. 最长的美好子字符串
 当一个字符串 s 包含的每一种字母的大写和小写形式 同时 出现在 s 中，就称这个字符串 s 是 美好 字符串。比方说，"abABB" 是美好字符串，因为 'A' 和 'a' 同时出现了，且 'B' 和 'b' 也同时出现了。然而，"abA" 不是美好字符串因为 'b' 出现了，而 'B' 没有出现。

 给你一个字符串 s ，请你返回 s 最长的 美好子字符串 。如果有多个答案，请你返回 最早 出现的一个。如果不存在美好子字符串，请你返回一个空字符串。

 示例 1：
     输入：s = "YazaAay"
     输出："aAa"
     解释："aAa" 是一个美好字符串，因为这个子串中仅含一种字母，其小写形式 'a' 和大写形式 'A' 也同时出现了。
     "aAa" 是最长的美好子字符串。
 示例 2：
     输入：s = "Bb"
     输出："Bb"
     解释："Bb" 是美好字符串，因为 'B' 和 'b' 都出现了。整个字符串也是原字符串的子字符串。
 示例 3：
     输入：s = "c"
     输出：""
     解释：没有美好子字符串。
 示例 4：
     输入：s = "dDzeE"
     输出："dD"
     解释："dD" 和 "eE" 都是最长美好子字符串。
     由于有多个美好子字符串，返回 "dD" ，因为它出现得最早。
 提示：
     1 <= s.length <= 100
     s 只包含大写和小写英文字母。
 */
@objcMembers class Problem1763: NSObject {
    func solution() {
        print(longestNiceSubstringLast("YazaAay"))
//        print(longestNiceSubstring("Bb"))
//        print(longestNiceSubstring("c"))
//        print(longestNiceSubstring("dDzeE"))
//        print(longestNiceSubstringLast("BebjJE"))
    }
    
    func longestNiceSubstringLast(_ s: String) -> String {
        var maxValue = 0
        var maxIndex = 0
        var lastC: String? = nil
        var lastI = 0
        for (i, c) in s.enumerated() {
            if c.uppercased() == lastC {
                continue
            } else {
                let len = i == 0 ? 1 : i - lastI
                if len > maxValue {
                    maxValue = len
                    maxIndex = lastI
                }
                lastI = i
                lastC = c.uppercased()
            }
        }
        print(maxIndex, maxValue)
        return ""
    }
    /*
     1: 创建一个二位数组 dp[[Int]]
     2: 遍历字符串，然后将字符的其实位置放入dp中，并计算该字符与上一个字符是否相等（包含大小写）
     */
    func longestNiceSubstring(_ s: String) -> String {
        var dp:[[Int]] = []
        
        var lastC: Character! = nil
        for (i,c) in s.enumerated() {
            guard let safeLastC = lastC else {
                lastC = c
                dp.append([i])
                continue
            }
            
            if c == safeLastC || c.asciiValue! + 32 == safeLastC.asciiValue! ||  c.asciiValue! - 32 == safeLastC.asciiValue! {
                if dp[dp.count-1].count == 1 {
                    dp[dp.count-1].append(i)
                } else {
                    dp[dp.count-1][1] = i
                }
            } else {
                lastC = c
                dp.append([i])
            }
        }
        
        var maxFirstIndex = -1
        var maxLastIndex = -1
        
        var firstIndex = -1
        var lastIndex = -1
        for array in dp {
            if array.count >= 2 {
                if firstIndex == -1 {
                    firstIndex = array[0]
                    lastIndex = array[1]
                } else {
                    lastIndex = array[1]
                }
                
                if lastIndex - firstIndex > maxLastIndex - maxFirstIndex{
                    maxFirstIndex = firstIndex
                    maxLastIndex = lastIndex
                }
            } else {
               firstIndex = -1
               lastIndex = -1
            }
        }
        if maxFirstIndex == -1 {
            return ""
        }
        print(dp)
        print(maxFirstIndex, maxLastIndex)
        return String(s[s.index(s.startIndex, offsetBy: maxFirstIndex)...s.index(s.startIndex, offsetBy: maxLastIndex)])
    }
}
